package com.ruoyi.system.service.impl;

import java.util.List;
import java.util.UUID;

import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.common.BaseInsertService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.BrandMapper;
import com.ruoyi.system.domain.Brand;
import com.ruoyi.system.service.IBrandService;

// pinyin4j
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
import org.springframework.transaction.annotation.Transactional;

/**
 * 品牌信息Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-10-30
 */
@Service
public class BrandServiceImpl extends BaseInsertService<Brand> implements IBrandService
{
    @Autowired
    private BrandMapper brandMapper;

    /**
     * 查询品牌信息
     * 
     * @param id 品牌信息主键
     * @return 品牌信息
     */
    @Override
    public Brand selectBrandById(String id)
    {
        return brandMapper.selectBrandById(id);
    }

    /**
     * 查询品牌信息列表
     * 
     * @param brand 品牌信息
     * @return 品牌信息
     */
    @Override
    public List<Brand> selectBrandList(Brand brand)
    {
        return brandMapper.selectBrandList(brand);
    }




//    /**
//     * 新增品牌信息
//     *
//     * @param brand 品牌信息
//     * @return 结果
//     */
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public int insertBrand(Brand brand) {
//        // 1️⃣ 基础字段校验
//        if (brand.getBrandName() == null || brand.getBrandName().trim().isEmpty()) {
//            throw new IllegalArgumentException("品牌名称不能为空");
//        }
//
//        // 2️⃣ 前置查重（提高用户体验）
//        List<Brand> existingBrands = brandMapper.selectBrandList(new Brand() {{
//            setBrandName(brand.getBrandName());
//        }});
//        if (!existingBrands.isEmpty()) {
//            throw new IllegalArgumentException("品牌名称已存在: " + brand.getBrandName());
//        }
//
//        // 3️⃣ 生成主键ID
//        brand.setId(UUID.randomUUID().toString().replace("-", ""));
//        brand.setCreateTime(DateUtils.getNowDate());
//
//        // 4️⃣ 自动生成或保留品牌编号
//        if (brand.getBrandCode() == null || brand.getBrandCode().isEmpty()) {
//            brand.setBrandCode(generateBrandCode(brand.getBrandName()));
//        }
//
//        try {
//            // 5️⃣ 插入数据库
//            return brandMapper.insertBrand(brand);
//        } catch (DuplicateKeyException e) {
//            // 6️⃣ 并发兜底处理（来自数据库唯一约束）
//            String message = e.getMessage();
//            if (message.contains("uk_brand_name")) {
//                throw new IllegalArgumentException("品牌名称已存在: " + brand.getBrandName());
//            } else if (message.contains("uk_brand_code")) {
//                throw new IllegalArgumentException("品牌编号已存在: " + brand.getBrandCode());
//            } else {
//                throw new RuntimeException("插入品牌失败，数据库唯一约束冲突", e);
//            }
//        }
//    }
//
////    TODO：生成品牌编号的方法太垃圾了，需要改进
//    private String generateBrandCode(String brandName) {
//        // 1. 将品牌名称转换为拼音友好标识
//        String slug = toPinyinSlug(brandName);
//
//        // 2. 取第一个单词或前缀
//        String prefix = slug.split("-")[0]; // 例如：'nixiya' -> 'nixiya'
//
//        // 3. 截取前缀（例如取前三个字母），并确保非空
//        if (prefix.length() > 3) {
//            prefix = prefix.substring(0, 3);
//        }
//        if (prefix.isEmpty()) {
//            prefix = "BR"; // 兜底前缀
//        }
//
//        // 4. 组合：使用拼音前缀 + 时间戳/随机数
//        // 注意：System.nanoTime() 比 System.currentTimeMillis() 更能降低冲突概率
//        return prefix.toUpperCase() + System.nanoTime();
//    }
//




    /**
     * 修改品牌信息
     * 
     * @param brand 品牌信息
     * @return 结果
     */
    @Override
    public int updateBrand(Brand brand)
    {
        brand.setUpdateTime(DateUtils.getNowDate());
        return brandMapper.updateBrand(brand);
    }

    /**
     * 批量删除品牌信息
     * 
     * @param ids 需要删除的品牌信息主键
     * @return 结果
     */
    @Override
    public int deleteBrandByIds(String[] ids)
    {
        return brandMapper.deleteBrandByIds(ids);
    }

    /**
     * 删除品牌信息信息
     * 
     * @param id 品牌信息主键
     * @return 结果
     */
    @Override
    public int deleteBrandById(String id)
    {
        return brandMapper.deleteBrandById(id);
    }

    @Override
    public int insertBrand(Brand brand) {
        // ✅ 直接调用模板逻辑
        return insertEntity(brand);
    }

    @Override
    protected void validateBeforeInsert(Brand brand) {
        if (brand.getBrandName() == null || brand.getBrandName().trim().isEmpty()) {
            throw new IllegalArgumentException("品牌名称不能为空");
        }
    }

    @Override
    protected boolean existsByUniqueField(Brand brand) {
        List<Brand> list = brandMapper.selectBrandList(new Brand() {{
            setBrandName(brand.getBrandName());
        }});
        return !list.isEmpty();
    }

    @Override
    protected Object getUniqueFieldValue(Brand brand) {
        return brand.getBrandName();
    }

    @Override
    protected void setBusinessCodeIfAbsent(Brand brand) {
        if (brand.getBrandCode() == null || brand.getBrandCode().isEmpty()) {
            brand.setBrandCode(generateBrandCode(brand.getBrandName()));
        }
    }

    @Override
    protected int doInsert(Brand brand) {
        return brandMapper.insertBrand(brand);
    }

    @Override
    protected void handleDuplicateKey(DuplicateKeyException e, Brand brand) {
        String msg = e.getMessage();
        if (msg.contains("uk_brand_name")) {
            throw new IllegalArgumentException("品牌名称已存在：" + brand.getBrandName());
        } else if (msg.contains("uk_brand_code")) {
            throw new IllegalArgumentException("品牌编号已存在：" + brand.getBrandCode());
        }
    }

    private String generateBrandCode(String brandName) {
        String prefix = toPinyinSlug(brandName);
        if (prefix.length() > 3) {
            prefix = prefix.substring(0, 3);
        }
        return prefix.toUpperCase() + System.nanoTime();
    }

    /**
     * 将中文/混合字符串转换为 URL/标识友好的小写拼音 slug
     * 规则：中文转为拼音（首选读音），英数字保留，空白转为 '-', 其它符号忽略；合并连续 '-' 并截断至 100 字符
     */
    private String toPinyinSlug(String input) {
        if (input == null) {
            return "";
        }
        input = input.trim();
        if (input.isEmpty()) {
            return "";
        }
        HanyuPinyinOutputFormat fmt = new HanyuPinyinOutputFormat();
        fmt.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        fmt.setVCharType(HanyuPinyinVCharType.WITH_V);
        fmt.setCaseType(HanyuPinyinCaseType.LOWERCASE);

        StringBuilder sb = new StringBuilder();
        for (char ch : input.toCharArray()) {
            // 判断中文字符范围
            if (Character.toString(ch).matches("[\\u4E00-\\u9FFF]")) {
                try {
                    String[] pinyins = PinyinHelper.toHanyuPinyinStringArray(ch, fmt);
                    if (pinyins != null && pinyins.length > 0) {
                        sb.append(pinyins[0]);
                    }
                } catch (BadHanyuPinyinOutputFormatCombination e) {
                    // 忽略该字符的拼音
                }
            } else {
                if (Character.isLetterOrDigit(ch)) {
                    sb.append(Character.toLowerCase(ch));
                } else if (Character.isWhitespace(ch) || ch == '-' || ch == '_') {
                    sb.append('-');
                } // 其它符号忽略
            }
        }
        String slug = sb.toString().replaceAll("-{2,}", "-");
        // 去除首尾 '-'
        slug = slug.replaceAll("^-|-$", "");
        // 截断，避免过长
        int max = 100;
        if (slug.length() > max) {
            slug = slug.substring(0, max);
        }
        return slug;
    }


}
